import PLPTP1
import Test.HUnit

-- Tests Aplicando

testsAplicando = [ TestCase $ assertEqual
	"aplicando funciona para el traductor mas sencillo"
	"abcdefghi"
	(aplicando identidad "abcdefghi") ]

-- Tests Intercambiar

testIntercambiar = TestCase $ assertEqual
	"Intercambia bien un string" 
	"baba"
	(aplicando intercambiarConsecutivos "abab")

testIntercambiarSoloDos = TestCase $ assertEqual
	"Intercambia bien un string de solo dos caracteres"
	"dc"
	(aplicando intercambiarConsecutivos "cd")

testIntercambiarInfinita = TestCase $ assertEqual
	"Genera la cadena infinita correcta"
	"abababab"
	(take 8 $ aplicando intercambiarConsecutivos (cycle "ba"))

testsIntercambiarConsecutivos = [
	testIntercambiar,
	testIntercambiarSoloDos,
	testIntercambiarInfinita ]

-- Tests Espejar Entre Aes

testEspejar = TestCase $ assertEqual
	"Espeja cuando hay solo dos aes"
	"abcda"
	(aplicando espejarEntreAs "adcba")

testEspejarCatedra = TestCase $ assertEqual
	"Espeja el caso de la catedra"
	"321a654aa987a"
	(aplicando espejarEntreAs "123a456aa789a")

testEspejarInfinita = TestCase $ assertEqual
	"Espeja una lista infinita"
	"abcdabcd"
	(take 8 $ aplicando espejarEntreAs
		(cycle "adcb")) 

testEspejarVacio = TestCase $ assertEqual
	"Espeja cuando solo hay dos as"
	"aa" (aplicando espejarEntreAs "aa")
	
testEspejarEntreAs = [
	testEspejar,
	testEspejarCatedra,
	testEspejarInfinita,
	testEspejarVacio ]

-- Tests Clausura de Kleene para estados

testTransicionKleeneCatedra = TestCase $ assertEqual
	"Calcula la transicion de Kleene en el ejemplo de la catedra"
	2
	(let (f,g,0) = acumularAes in (fAst f) 0 "cazaa")

testTransicionKleeneVacia = TestCase $ assertEqual
	"Si le doy la cadena vacia termina en el mismo estado"
	(Just 'a')
	(let (f,g,_) = intercambiarConsecutivos in
		(fAst f) (Just 'a') "")

testTransicionKleeneConsecutivos = TestCase $ assertEqual
	"Transiciona bien para el traductor consecutivo"
	(Just 'b')
	(let (f,g,_) = intercambiarConsecutivos in
<<<<<<< HEAD
		(fAst f (Nothing) "abb"))
=======
		(fAst f) Nothing "abb")
>>>>>>> 46ae5c0afc8f6baa91c2c53ac525699bab8a7b8d
	
testTransicionKleene = [
	testTransicionKleeneCatedra,
	testTransicionKleeneVacia,
	testTransicionKleeneConsecutivos ]

-- Tests clausura de Kleene para outputs

testTransicionKleeneOutputCatedra = TestCase $ assertEqual
	"Obtiene el output correcto para el ejemplo de la catedra"
	"cza"
	(let (f,g,q) = acumularAes in (gAst f g) q "cazaa")

testTransicionKleeneOutputCambiarAE = TestCase $ assertEqual
	"Obtiene el output correcto para cambiar aes"
	"cazadores"
	(let (f,g,q) = cambiarAE in (gAst f g) q "cezedoras")	

testTransicionKleeneIntercambiarConsecutivos = TestCase $ assertEqual
	"Obtiene el output correcto para intercambiar consecutivos"
	"caba"
	(let (f,g,q) = intercambiarConsecutivos in (gAst f g) q "acab")

testTransicionKleeneOutput = [
	testTransicionKleeneOutputCatedra,
	testTransicionKleeneOutputCambiarAE,
	testTransicionKleeneIntercambiarConsecutivos ]

-- Tests composicion

testCompCatedra = TestCase $ assertEqual
	"La composicion reversible es como la que uno esperaria"
	"abcdea"
	(aplicando (comp intercambiarConsecutivos 
					intercambiarConsecutivos) "abcdea")

testCompAE = TestCase $ assertEqual
	"La composicion de cosas distintas es como la que se espera"
	"bedcea"
	(aplicando (comp cambiarAE intercambiarConsecutivos) "abcdea")

testCompAcumYAE = TestCase $ assertEqual
	"La composicion es en el orden que uno la espera"
	"zaaaa"
	(aplicando (comp acumularAes cambiarAE) "eeeez")

testComp = [
	testCompCatedra,
	testCompAE,
	testCompAcumYAE ]

-- Tests salidaAes

testSalidaAesFacil = TestCase $ assertEqual
	"salidaAes funciona para cambiarAE"
	"eeeee"
	(take 5 $ salidaAes cambiarAE)

testSalidaAesEspejar = TestCase $ assertEqual
	"salidaAes funciona para espejar A"
	"aaaaa"
	(take 5 $ salidaAes espejarEntreAs)

testSalidaAes = [
	testSalidaAesFacil,
	testSalidaAesEspejar ]

-- Tests salidaPosible

testSalidaPosibleFacil = TestCase $ assertEqual
	"salidaPosible funciona para cambiarAE"
	True
	(salidaPosible cambiarAE "1234")

testSalidaPosibleIntercambiarCons = TestCase $ assertEqual
	"salidaPosible funciona para intercambiarConsecutivos"
	True
	(salidaPosible intercambiarConsecutivos "2134")

testSalidaPosibleIntercambiarConsFalse = TestCase $ assertEqual
	"salidaPosible funciona para intercambiarConsecutivos"
	False
	(salidaPosible intercambiarConsecutivos "123")

testSalidaPosibleSiNoHay0Sueltos = TestCase $ assertEqual
	"salidaPosible deberia poder generar esa cadena sin ceros"
	True
	(salidaPosible sin0Sueltos "10023")

testSalidaPosibleHay0Sueltos = TestCase $ assertEqual
	"salidaPosible deberia poder generar esa cadena con ceros"
	False
	(salidaPosible sin0Sueltos "00203")

testSalidaPosibleHayAFinal0 = TestCase $ assertEqual
	"salidaPosible deberia poder generar esa cadena con cero al final"
	True
	(salidaPosible sin0Sueltos "10020")

testSalidaPosible = [
	testSalidaPosibleFacil,
	testSalidaPosibleIntercambiarCons,
	testSalidaPosibleIntercambiarConsFalse,
	testSalidaPosibleSiNoHay0Sueltos,
	testSalidaPosibleHay0Sueltos,
	testSalidaPosibleHayAFinal0 ]

-- Tests salida Aes

testSalidaAesBasico = TestCase $ assertEqual
	"Tomar aes funciona para un traductor basico"
	(take 10 $ cycle "e")
	(take 10 $ salidaAes cambiarAE)

testSalidaAes = [
	testSalidaAesBasico
	]

-- Tests Salida Posible

testSalidaPosibleBasico = TestCase $ assertEqual
	"Funciona para la Salida basica"
	True
	(salidaPosible cambiarAE "eeeee")

testSalidaPosibleBasicoNegativa = TestCase $ assertEqual
	"No funciona para una salida basica"
	False
	(salidaPosible cambiarAE "bcd")

testSalidaPosible = [
	testSalidaPosibleBasico,
	testSalidaPosibleBasicoNegativa
	]

main = runTestTT $ TestList $ concat [
	testsAplicando,
	testsIntercambiarConsecutivos,
	testEspejarEntreAs,
	testTransicionKleene,
	testTransicionKleeneOutput,
	testComp,
	testSalidaAes,
<<<<<<< HEAD
	testSalidaPosible
	]
=======
	testSalidaPosible ]
>>>>>>> 46ae5c0afc8f6baa91c2c53ac525699bab8a7b8d
